package com.practice.designMode.factory;

interface Shape{
    void draw();
}

class Circle implements Shape{
    @Override
    public void draw(){
        System.out.println("draw a circle");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

// 颜色接口
interface Color {
    void fill();
}

// 红色类
class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Red color");
    }
}

// 蓝色类
class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Blue color");
    }
}



/**
 * 简单工厂模式是一种最简单的工厂模式，
 * 它通过一个工厂类直接创建对象，但不提供接口或抽象类。
 * 工厂类通常包含一个静态方法，根据传入的参数决定创建哪种对象。
 * 工厂类包含所有对象的创建逻辑。
 * 客户端只需要调用工厂类的方法，传入参数即可获取对象。
 * 缺点是工厂类职责过重，违反了开闭原则（对扩展开放，对修改关闭）。
 */
//简单工厂类
//class ShapeFactory{
//    public static Shape getShape(String shapeType){
//        if(shapeType==null){
//            return null;
//        }
//        if(shapeType.equalsIgnoreCase("CIRCLE")){
//            return new Circle();
//        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
//            return new Square();
//        }
//        return null;
//    }
//}

/**
 *工厂方法模式是一种更灵活的工厂模式
 * 它通过定义一个工厂接口或抽象类，并让子类决定创建哪种对象。
 * 工厂方法模式的核心是将对象的创建逻辑封装在工厂类中，而客户端只需要调用工厂方法即可。
 * 工厂方法模式提供了一个创建对象的接口，但具体的实现由子类完成。
 * 符合开闭原则，当需要添加新的对象时，只需要添加新的工厂子类即可。
  */
////工厂接口
//interface ShapeFactory{
//    Shape getShape();
//}
////圆形工厂
//class CircleFactroy implements ShapeFactory{
//    @Override
//    public Shape getShape() {
//        return new Circle();
//    }
//}
////方形工厂
//class SquareFactory implements ShapeFactory{
//    @Override
//    public Shape getShape() {
//        return new Square();
//    }
//}

/**
 * 抽象工厂模式是最复杂的工厂模式，
 * 它用于创建一组相关或依赖的对象，而无需指定它们的具体类。
 * 抽象工厂模式定义了一个工厂接口，用于创建一组相关对象，而具体的实现由子类完成。
 */
//抽象工厂接口
interface AbstractFactory{
    Color getColor(String color);
    Shape getShape(String shape);
}

// 颜色工厂
class ColorFactory implements AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("BLUE")) {
            return new Blue();
        }
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        return null;
    }
}

// 图形工厂
class ShapeFactory implements AbstractFactory {
    @Override
    public Color getColor(String color) {
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        if (shape == null) {
            return null;
        }
        if (shape.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shape.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

// 工厂生成器
class FactoryProducer {
    public static AbstractFactory getFactory(String choice) {
        if (choice == null) {
            return null;
        }
        if (choice.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (choice.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }
        return null;
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        Shape shape = shapeFactory.getShape("CIRCLE");
        shape.draw(); // 输出：Drawing a Circle

        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        Color color = colorFactory.getColor("RED");
        color.fill(); // 输出：Filling with Red color
    }
}
